home *** CD-ROM | disk | FTP | other *** search
/ OpenGL Superbible (2nd Edition) / OpenGL SuperBible e2.iso / tools / GLUT-3.7 / TEST / GLUT / TEST6.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-12  |  11.8 KB  |  521 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1994, 1997. */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. /* This is an interactive test (not automatically run by "make
  9.    test") that requires user interaction to verify that input
  10.    callbacks operate as expected. */
  11.  
  12. #include <stdlib.h>
  13. #include <stdio.h>
  14. #include <GL/glut.h>
  15.  
  16. static int mouseButtons;
  17.  
  18. void
  19. display(void)
  20. {
  21.   glClear(GL_COLOR_BUFFER_BIT);
  22.   glFlush();
  23. }
  24.  
  25. void
  26. time7(int value)
  27. {
  28.   if (value != 7) {
  29.     printf("FAIL: time7 expected 6\n");
  30.     exit(1);
  31.   }
  32.   printf("PASS: test6\n");
  33.   exit(0);
  34. }
  35.  
  36. void
  37. mstatus(int state)
  38. {
  39.   printf("state: %d\n", state);
  40. }
  41.  
  42. void
  43. mstatus2(int state, int x, int y)
  44. {
  45.   printf("state: %d, x=%d, y=%d\n", state, x, y);
  46. }
  47.  
  48. void
  49. menu2(int value)
  50. {
  51.   printf("menu item selected: %d\n", value);
  52.   if (value != 46) {
  53.     printf("FAIL: time6 expected 45\n");
  54.     exit(1);
  55.   }
  56.   glutDestroyMenu(glutGetMenu());
  57.   glutDestroyWindow(glutGetWindow());
  58.   glutTimerFunc(1000, time7, 7);
  59. }
  60.  
  61. void
  62. time6(int value)
  63. {
  64.   if (value != 6) {
  65.     printf("FAIL: time6 expected 6\n");
  66.     exit(1);
  67.   }
  68.   glutMenuStateFunc(mstatus);
  69.   glutMenuStatusFunc(mstatus2);
  70.   glutCreateMenu(menu2);
  71.   glutAddMenuEntry("name", 46);
  72.   glutAttachMenu(GLUT_LEFT_BUTTON);
  73.   glutAttachMenu(GLUT_MIDDLE_BUTTON);
  74.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  75.   printf("Pop up menu with any mouse button and select the item\n");
  76. }
  77.  
  78. int estate = 0;
  79.  
  80. void
  81. entry(int state)
  82. {
  83.   printf("entry: %s\n", state == GLUT_LEFT ? "left" : "entered");
  84.   switch (estate) {
  85.   case 0:
  86.     if (state == GLUT_LEFT)
  87.       estate++;
  88.     break;
  89.   case 1:
  90.     if (state == GLUT_ENTERED)
  91.       estate++;
  92.     glutTimerFunc(1000, time6, 6);
  93.     glutEntryFunc(NULL);
  94.     break;
  95.   }
  96. }
  97.  
  98. void
  99. time5(int value)
  100. {
  101.   if (value != 5) {
  102.     printf("FAIL: time5 expected 5\n");
  103.     exit(1);
  104.   }
  105.   glutEntryFunc(entry);
  106.   printf("In the black window, leave it, then enter it\n");
  107. }
  108.  
  109. void
  110. motion(int x, int y)
  111. {
  112.   printf("motion x=%d, y=%d\n", x, y);
  113.   glutMotionFunc(NULL);
  114.   glutTimerFunc(1000, time5, 5);
  115. }
  116.  
  117. void
  118. time4(int value)
  119. {
  120.   if (value != 4) {
  121.     printf("FAIL: time4 expected 4\n");
  122.     exit(1);
  123.   }
  124.   glutMotionFunc(motion);
  125.   printf("In the black window, move mouse with some button held down\n");
  126. }
  127.  
  128. void
  129. passive(int x, int y)
  130. {
  131.   printf("passive x=%d, y=%d\n", x, y);
  132.   glutTimerFunc(1000, time4, 4);
  133.   glutPassiveMotionFunc(NULL);
  134. }
  135.  
  136. void
  137. time3(int value)
  138. {
  139.   if (value != 3) {
  140.     printf("FAIL: time3 expected 3\n");
  141.     exit(1);
  142.   }
  143.   glutPassiveMotionFunc(passive);
  144.   printf("In the black window, mouse the mouse around with NO buttons down\n");
  145. }
  146.  
  147. static int mode = 0;
  148.  
  149. void
  150. mouse(int button, int state, int x, int y)
  151. {
  152.   printf("but=%d, state=%d, x=%d, y=%d, modifiers=0x%x\n",
  153.     button, state, x, y, glutGetModifiers());
  154.   switch (mode) {
  155.   case 0:
  156.     if (button != GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  157.       printf("FAIL: mouse left down not found\n");
  158.       exit(1);
  159.     }
  160.     if (glutGetModifiers() != 0) {
  161.       printf("FAIL: mouse expected no modifier\n");
  162.       exit(1);
  163.     }
  164.     mode++;
  165.     break;
  166.   case 1:
  167.     if (button != GLUT_LEFT_BUTTON && state == GLUT_UP) {
  168.       printf("FAIL: mouse left up not found\n");
  169.       exit(1);
  170.     }
  171.     if (glutGetModifiers() != 0) {
  172.       printf("FAIL: mouse expected no modifier\n");
  173.       exit(1);
  174.     }
  175.     switch (mouseButtons) {
  176.     case 1:
  177.       mode = 6;         /* Skip right or middle button tests. */
  178.       printf("In the black window, please click: Shift-left, Ctrl-left, then Alt-left (in that order)\n");
  179.       break;
  180.     case 2:
  181.       mode = 4;         /* Continue with right button test
  182.                            (skip middle button). */
  183.       break;
  184.     case 3:
  185.       mode = 2;         /* Continue with middle button test. */
  186.       break;
  187.     }
  188.     break;
  189.   case 2:
  190.     if (button != GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) {
  191.       printf("FAIL: mouse center down not found\n");
  192.       exit(1);
  193.     }
  194.     if (glutGetModifiers() != 0) {
  195.       printf("FAIL: mouse expected no modifier\n");
  196.       exit(1);
  197.     }
  198.     mode++;
  199.     break;
  200.   case 3:
  201.     if (button != GLUT_MIDDLE_BUTTON && state == GLUT_UP) {
  202.       printf("FAIL: mouse center up not found\n");
  203.       exit(1);
  204.     }
  205.     if (glutGetModifiers() != 0) {
  206.       printf("FAIL: mouse expected no modifier\n");
  207.       exit(1);
  208.     }
  209.     mode++;
  210.     break;
  211.   case 4:
  212.     if (button != GLUT_RIGHT_BUTTON && state == GLUT_DOWN) {
  213.       printf("FAIL: mouse right down not found\n");
  214.       exit(1);
  215.     }
  216.     if (glutGetModifiers() != 0) {
  217.       printf("FAIL: mouse expected no modifier\n");
  218.       exit(1);
  219.     }
  220.     mode++;
  221.     break;
  222.   case 5:
  223.     if (button != GLUT_RIGHT_BUTTON && state == GLUT_UP) {
  224.       printf("FAIL: mouse right up not found\n");
  225.       exit(1);
  226.     }
  227.     if (glutGetModifiers() != 0) {
  228.       printf("FAIL: mouse expected no modifier\n");
  229.       exit(1);
  230.     }
  231.     printf("In the black window, please click: Shift-left, Ctrl-left, then Alt-left (in that order)\n");
  232.     mode++;
  233.     break;
  234.   case 6:
  235.     if (button != GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  236.       printf("FAIL: mouse right down not found\n");
  237.       exit(1);
  238.     }
  239.     if (glutGetModifiers() != GLUT_ACTIVE_SHIFT) {
  240.       printf("FAIL: mouse expected shift modifier\n");
  241.       exit(1);
  242.     }
  243.     mode++;
  244.     break;
  245.   case 7:
  246.     if (button != GLUT_LEFT_BUTTON && state == GLUT_UP) {
  247.       printf("FAIL: mouse right down not found\n");
  248.       exit(1);
  249.     }
  250.     if (glutGetModifiers() != GLUT_ACTIVE_SHIFT) {
  251.       printf("FAIL: mouse expected shift modifier\n");
  252.       exit(1);
  253.     }
  254.     mode++;
  255.     break;
  256.   case 8:
  257.     if (button != GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  258.       printf("FAIL: mouse right down not found\n");
  259.       exit(1);
  260.     }
  261.     if (glutGetModifiers() != GLUT_ACTIVE_CTRL) {
  262.       printf("FAIL: mouse expected ctrl modifier\n");
  263.       exit(1);
  264.     }
  265.     mode++;
  266.     break;
  267.   case 9:
  268.     if (button != GLUT_LEFT_BUTTON && state == GLUT_UP) {
  269.       printf("FAIL: mouse right down not found\n");
  270.       exit(1);
  271.     }
  272.     if (glutGetModifiers() != GLUT_ACTIVE_CTRL) {
  273.       printf("FAIL: mouse expected ctrl modifier\n");
  274.       exit(1);
  275.     }
  276.     mode++;
  277.     break;
  278.   case 10:
  279.     if (button != GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  280.       printf("FAIL: mouse right down not found\n");
  281.       exit(1);
  282.     }
  283.     if (glutGetModifiers() != GLUT_ACTIVE_ALT) {
  284.       printf("FAIL: mouse expected alt modifier\n");
  285.       exit(1);
  286.     }
  287.     mode++;
  288.     break;
  289.   case 11:
  290.     if (button != GLUT_LEFT_BUTTON && state == GLUT_UP) {
  291.       printf("FAIL: mouse right down not found\n");
  292.       exit(1);
  293.     }
  294.     if (glutGetModifiers() != GLUT_ACTIVE_ALT) {
  295.       printf("FAIL: mouse expected alt modifier\n");
  296.       exit(1);
  297.     }
  298.     glutTimerFunc(1000, time3, 3);
  299.     glutMouseFunc(NULL);
  300.     mode++;
  301.     break;
  302.   default:
  303.     printf("FAIL: mouse called with bad mode: %d\n", mode);
  304.     exit(1);
  305.   }
  306. }
  307.  
  308. /* ARGSUSED */
  309. void
  310. menu(int selection)
  311. {
  312.   printf("FAIL: menu callback should never be called\n");
  313.   exit(1);
  314. }
  315.  
  316. void
  317. time2(int value)
  318. {
  319.   if (value != 2) {
  320.     printf("FAIL: time2 expected 2\n");
  321.     exit(1);
  322.   }
  323.   glutMouseFunc(mouse);
  324.  
  325.   /* By attaching and detaching a menu to each button, make
  326.      sure button usage for menus does not mess up normal button 
  327.  
  328.      callback. */
  329.   glutCreateMenu(menu);
  330.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  331.   glutAttachMenu(GLUT_MIDDLE_BUTTON);
  332.   glutAttachMenu(GLUT_LEFT_BUTTON);
  333.   glutDetachMenu(GLUT_RIGHT_BUTTON);
  334.   glutDetachMenu(GLUT_MIDDLE_BUTTON);
  335.   glutDetachMenu(GLUT_LEFT_BUTTON);
  336.   glutDestroyMenu(glutGetMenu());
  337.  
  338.   switch (mouseButtons) {
  339.   case 3:
  340.     printf("In the black window, please click: left, then middle, then right buttons (in that order)\n");
  341.     break;
  342.   case 2:
  343.     printf("In the black window, please click: left, then right buttons (in that order)\n");
  344.     break;
  345.   case 1:
  346.     printf("In the black window, please click: left button\n");
  347.     break;
  348.   case 0:
  349.     /* No mouse buttons??  Skip all subsequent tests since they 
  350.        involve the mouse. */
  351.     glutTimerFunc(1000, time7, 7);
  352.     glutMouseFunc(NULL);
  353.     break;
  354.   }
  355. }
  356.  
  357. int smode = 0;
  358.  
  359. /* XXX Warning, sometimes an X window manager will intercept
  360.    some keystroke like Alt-F2.  Be careful about window manager
  361.    interference when running test6. */
  362.  
  363. void
  364. special(int key, int x, int y)
  365. {
  366.   printf("key=%d, x=%d, y=%d, modifiers=0x%x\n",
  367.     key, x, y, glutGetModifiers());
  368.   switch (smode) {
  369.   case 0:
  370.     if (key != GLUT_KEY_F2) {
  371.       printf("FAIL: special expected F2\n");
  372.       exit(1);
  373.     }
  374.     if (glutGetModifiers() != 0) {
  375.       printf("FAIL: special expected no modifier\n");
  376.       exit(1);
  377.     }
  378.     break;
  379.   case 1:
  380.     if (key != GLUT_KEY_F2) {
  381.       printf("FAIL: special expected F2\n");
  382.       exit(1);
  383.     }
  384.     if (glutGetModifiers() != GLUT_ACTIVE_SHIFT) {
  385.       printf("FAIL: special expected shift modifier\n");
  386.       exit(1);
  387.     }
  388.     break;
  389.   case 2:
  390.     if (key != GLUT_KEY_F2) {
  391.       printf("FAIL: special expected F2\n");
  392.       exit(1);
  393.     }
  394.     if (glutGetModifiers() != GLUT_ACTIVE_CTRL) {
  395.       printf("FAIL: special expected ctrl modifier\n");
  396.       exit(1);
  397.     }
  398.     break;
  399.   case 3:
  400.     if (key != GLUT_KEY_F2) {
  401.       printf("FAIL: special expected F2\n");
  402.       exit(1);
  403.     }
  404.     if (glutGetModifiers() != GLUT_ACTIVE_ALT) {
  405.       printf("FAIL: special expected alt modifier\n");
  406.       exit(1);
  407.     }
  408.     glutSpecialFunc(NULL);
  409.     glutTimerFunc(1000, time2, 2);
  410.     break;
  411.   default:
  412.     printf("FAIL: special called with bad mode: %d\n", smode);
  413.     exit(1);
  414.   }
  415.   smode++;
  416. }
  417.  
  418. void
  419. time1(int value)
  420. {
  421.   printf("PLEASE EXPECT TO SEE A WARNING ON THE NEXT LINE:\n");
  422.   glutGetModifiers();
  423.   printf("DID YOU SEE A WARNING?  IT IS AN ERROR NOT TO SEE ONE.\n");
  424.   if (value != 1) {
  425.     printf("FAIL: time1 expected 1\n");
  426.     exit(1);
  427.   }
  428.   glutSpecialFunc(special);
  429.   printf("In the black window, please press: F2, Shift-F2, Ctrl-F2, then Alt-F2\n");
  430. }
  431. int kmode = 0;
  432.  
  433. void
  434. keyboard(unsigned char c, int x, int y)
  435. {
  436.   printf("char=%d, x=%d, y=%d, modifiers=0x%x\n",
  437.     c, x, y, glutGetModifiers());
  438.   switch (kmode) {
  439.   case 0:
  440.     if (c != 'g') {
  441.       printf("FAIL: keyboard expected g\n");
  442.       exit(1);
  443.     }
  444.     if (glutGetModifiers() != 0) {
  445.       printf("FAIL: keyboard expected no modifier\n");
  446.       exit(1);
  447.     }
  448.     break;
  449.   case 1:
  450.     if (c != 'G') {
  451.       printf("FAIL: keyboard expected G\n");
  452.       exit(1);
  453.     }
  454.     if (glutGetModifiers() != GLUT_ACTIVE_SHIFT) {
  455.       printf("FAIL: keyboard expected shift modifier\n");
  456.       exit(1);
  457.     }
  458.     break;
  459.   case 2:
  460.     if (c != 0x7) {     /* Bell, Ctrl-g */
  461.       printf("FAIL: keyboard expected g\n");
  462.       exit(1);
  463.     }
  464.     if (glutGetModifiers() != GLUT_ACTIVE_CTRL) {
  465.       printf("FAIL: keyboard expected ctrl modifier\n");
  466.       exit(1);
  467.     }
  468.     break;
  469.   case 3:
  470.     if (c != 'g') {
  471.       printf("FAIL: keyboard expected g\n");
  472.       exit(1);
  473.     }
  474.     if (glutGetModifiers() != GLUT_ACTIVE_ALT) {
  475.       printf("FAIL: keyboard expected alt modifier\n");
  476.       exit(1);
  477.     }
  478.     glutKeyboardFunc(NULL);
  479.     glutTimerFunc(1000, time1, 1);
  480.     break;
  481.   default:
  482.     printf("FAIL: keyboard called with bad mode: %d\n", kmode);
  483.     exit(1);
  484.   }
  485.   kmode++;
  486. }
  487.  
  488. void
  489. time0(int value)
  490. {
  491.   if (value != 0) {
  492.     printf("FAIL: time0 expected 0\n");
  493.     exit(1);
  494.   }
  495.   glutKeyboardFunc(keyboard);
  496.   printf("In the black window, please press: g, G, Ctrl-g, then Alt-g\n");
  497. }
  498.  
  499. int
  500. main(int argc, char **argv)
  501. {
  502.   glutInit(&argc, argv);
  503.   mouseButtons = glutDeviceGet(GLUT_NUM_MOUSE_BUTTONS);
  504.   if (mouseButtons < 0) {
  505.     printf("FAIL: negative mouse buttons? mouseButtons=%d\n",
  506.       mouseButtons);
  507.     exit(1);
  508.   }
  509.   if (mouseButtons > 3) {
  510.     printf("More than 3 mouse buttons (ok).  mouseButtons=%d\n",
  511.       mouseButtons);
  512.     mouseButtons = 3;  /* Testing only of 3 mouse buttons. */
  513.   }
  514.   mouseButtons = 0;
  515.   glutCreateWindow("test");
  516.   glutDisplayFunc(display);
  517.   glutTimerFunc(1000, time0, 0);
  518.   glutMainLoop();
  519.   return 0;             /* ANSI C requires main to return int. */
  520. }
  521.